home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / x / volume2 / x11.3 / patch5 < prev    next >
Encoding:
Internet Message Format  |  1989-01-09  |  49.5 KB
  1. Path: uunet!wyse!mikew
  2. From: mikew@wyse.wyse.com (Mike Wexler)
  3. Newsgroups: comp.sources.x
  4. Subject: v02i081:  X11 Release 3, Patch5
  5. Message-ID: <1976@wyse.wyse.com>
  6. Date: 10 Jan 89 01:41:19 GMT
  7. Organization: Wyse Technology, San Jose
  8. Lines: 1784
  9. Approved: mikew@wyse.com
  10.  
  11. Submitted-by: jim@expo.lcs.mit.edu (Jim Fulton)
  12. Posting-number: Volume 2, Issue 81
  13. Archive-name: x11.3/patch5
  14.  
  15.  
  16.  
  17.                Created on Monday, 9 January 1989
  18.  
  19.                   PART 1 of 3
  20.  
  21.  
  22. Fixes 5, 6, and 7 are part of a single update to the xman program.  Together
  23. they affect the following files:
  24.  
  25.     clients/xman/CHANGES
  26.     clients/xman/README
  27.     clients/xman/ScrollByL.c
  28.     clients/xman/TODO
  29.     clients/xman/buttons.c
  30.     clients/xman/defs.h
  31.     clients/xman/globals.c
  32.     clients/xman/globals.h
  33.     clients/xman/handler.c
  34.     clients/xman/help.c
  35.     clients/xman/main.c
  36.     clients/xman/man.c
  37.     clients/xman/man.h
  38.     clients/xman/menu.c
  39.     clients/xman/misc.c
  40.     clients/xman/pages.c
  41.     clients/xman/search.c
  42.     clients/xman/tkfuncs.c
  43.     clients/xman/version.h
  44.     clients/xman/xman.help
  45.     clients/xman/xman.man
  46.  
  47. To apply these fixes, concatenate all three files and pipe them to patch -p0
  48. from the top of your X sources:
  49.  
  50.     %  cat fix5 fix6 fix7 | patch -p0
  51.  
  52.  
  53. The following is fix5 (you will also need fix6 and fix7):
  54.  
  55.  
  56.  
  57. *** /tmp/,RCSt1a17149    Fri Jan  6 18:56:33 1989
  58. --- clients/xman/buttons.c    Fri Jan  6 18:41:55 1989
  59. ***************
  60. *** 1,8 ****
  61.   /*
  62.    * xman - X window system manual page display program.
  63.    *
  64. !  * $XConsortium: buttons.c,v 1.2 88/09/04 20:27:16 swick Exp $
  65. !  * $oHeader: buttons.c,v 4.0 88/08/31 22:11:26 kit Exp $
  66.    *
  67.    * Copyright 1987, 1988 Massachusetts Institute of Technology
  68.    *
  69. --- 1,8 ----
  70.   /*
  71.    * xman - X window system manual page display program.
  72.    *
  73. !  * $XConsortium: buttons.c,v 1.3 89/01/06 18:41:51 kit Exp $
  74. !  * $Header: buttons.c,v 1.3 89/01/06 18:41:51 kit Exp $
  75.    *
  76.    * Copyright 1987, 1988 Massachusetts Institute of Technology
  77.    *
  78. ***************
  79. *** 21,27 ****
  80.    */
  81.   
  82.   #if ( !defined(lint) && !defined(SABER))
  83. !   static char rcs_version[] = "$Athena: buttons.c,v 4.0 88/08/31 22:11:26 kit Exp $";
  84.   #endif
  85.   
  86.   #include "globals.h"
  87. --- 21,27 ----
  88.    */
  89.   
  90.   #if ( !defined(lint) && !defined(SABER))
  91. !   static char rcs_version[] = "$Athena: buttons.c,v 4.5 88/12/19 13:46:34 kit Exp $";
  92.   #endif
  93.   
  94.   #include "globals.h"
  95. ***************
  96. *** 45,53 ****
  97.   #define TOPARGS 5
  98.   
  99.   void
  100. ! MakeTopMenuWidget(top)
  101. ! Widget top;
  102.   {
  103.     Widget menu;            /* Top Box and menu. */
  104.     Menu topbox;            /* The menu structure for this box. */
  105.     Button topbuttons[TOPBUTTONS]; /* The button structure for these buttons. */
  106. --- 45,53 ----
  107.   #define TOPARGS 5
  108.   
  109.   void
  110. ! MakeTopMenuWidget()
  111.   {
  112. +   Widget top;            /* top box widget. */
  113.     Widget menu;            /* Top Box and menu. */
  114.     Menu topbox;            /* The menu structure for this box. */
  115.     Button topbuttons[TOPBUTTONS]; /* The button structure for these buttons. */
  116. ***************
  117. *** 60,65 ****
  118. --- 60,80 ----
  119.       "Manual Page"
  120.       };
  121.   
  122. + /* create the top icon. */
  123. + 
  124. +   num_args = 0;
  125. +   XtSetArg(arglist[num_args], XtNiconPixmap,
  126. +        XCreateBitmapFromData( XtDisplay(initial_widget), 
  127. +                  XtScreen(initial_widget)->root,
  128. +                  iconclosed_bits, iconclosed_width,
  129. +                  iconclosed_height));
  130. +   num_args++;
  131. +   XtSetArg(arglist[num_args], XtNallowShellResize, TRUE); 
  132. +   num_args++;
  133. + 
  134. +   top = XtCreatePopupShell(TOPBOXNAME, topLevelShellWidgetClass, 
  135. +                initial_widget, arglist, num_args);
  136. + 
  137.     /* Set up the manual structure. */
  138.   
  139.     topbox.number = TOPBUTTONS;
  140. ***************
  141. *** 73,79 ****
  142.     topbox.buttons = topbuttons;
  143.     topbox.callback = TopCallback;
  144.   
  145. ! /* Set up the button structures, by assiging each one a name and a 
  146.    * width, this puts either one button on a line or two depending on
  147.    * the length of the string that will go into the buttons. See Menu.c for 
  148.    * details.
  149. --- 88,95 ----
  150.     topbox.buttons = topbuttons;
  151.     topbox.callback = TopCallback;
  152.   
  153. ! /*
  154. !  * Set up the button structures, by assiging each one a name and a 
  155.    * width, this puts either one button on a line or two depending on
  156.    * the length of the string that will go into the buttons. See Menu.c for 
  157.    * details.
  158. ***************
  159. *** 91,105 ****
  160.     menu = MakeMenu(top,&topbox, NULL); /* Create the menu. */
  161.     XtManageChild(menu);        /* Manage the menu. */
  162.   
  163. ! /* create the top icon. */
  164. ! 
  165. !   num_args = 0;
  166. !   XtSetArg(arglist[num_args], XtNiconPixmap,
  167. !        XCreateBitmapFromData( XtDisplay(top), XtScreen(top)->root,
  168. !                  iconclosed_bits, iconclosed_width,
  169. !                  iconclosed_height));
  170. !   num_args++;
  171. !   XtSetValues(top,arglist,num_args);
  172.   }
  173.   
  174.   /*    Function Name: CreateManpage
  175. --- 107,115 ----
  176.     menu = MakeMenu(top,&topbox, NULL); /* Create the menu. */
  177.     XtManageChild(menu);        /* Manage the menu. */
  178.   
  179. !   XtRealizeWidget(top);
  180. !   XtMapWidget(top);
  181. !   AddCursor(top, resources.cursors.top);
  182.   }
  183.   
  184.   /*    Function Name: CreateManpage
  185. ***************
  186. *** 136,142 ****
  187.   
  188.   /* Initialize the number of screens that will be shown */
  189.   
  190. !   man_globals->both_shown = both_shown_initial;
  191.   
  192.     for ( i = 0 ; i < sections ; i++) 
  193.       man_globals->manpagewidgets.box[i] = NULL;
  194. --- 146,152 ----
  195.   
  196.   /* Initialize the number of screens that will be shown */
  197.   
  198. !   man_globals->both_shown = resources.both_shown_initial;
  199.   
  200.     for ( i = 0 ; i < sections ; i++) 
  201.       man_globals->manpagewidgets.box[i] = NULL;
  202. ***************
  203. *** 174,181 ****
  204.     XtSetArg(arglist[num_args], XtNheight, default_height);
  205.     num_args++; 
  206.   
  207. !   top = XtCreateApplicationShell(name, topLevelShellWidgetClass,
  208. !                  arglist, num_args);
  209.   
  210.     man_globals->This_Manpage = top; /* pointer to root widget of Manualpage. */
  211.     num_args = 0;
  212. --- 184,191 ----
  213.     XtSetArg(arglist[num_args], XtNheight, default_height);
  214.     num_args++; 
  215.   
  216. !   top = XtCreatePopupShell(name, topLevelShellWidgetClass, initial_widget,
  217. !                arglist, num_args);
  218.   
  219.     man_globals->This_Manpage = top; /* pointer to root widget of Manualpage. */
  220.     num_args = 0;
  221. ***************
  222. *** 215,230 ****
  223.       mpw->directory = XtCreateWidget(DIRECTORY_NAME, viewportWidgetClass,
  224.                       pane, arglist, num_args);
  225.       
  226. !     man_globals->current_directory = 1;
  227.       MakeDirectoryBox(man_globals, mpw->directory,
  228. !              mpw->box + man_globals->current_directory, 1);
  229.       XtManageChild(mpw->box[man_globals->current_directory]);
  230.     }
  231.   
  232.   /* Create Manpage */
  233.   
  234. !   font_height = (fonts.normal->max_bounds.ascent + 
  235. !            fonts.normal->max_bounds.descent);
  236.   
  237.     num_args = 0;
  238.     XtSetArg(arglist[num_args], XtNallowVert, TRUE);
  239. --- 225,241 ----
  240.       mpw->directory = XtCreateWidget(DIRECTORY_NAME, viewportWidgetClass,
  241.                       pane, arglist, num_args);
  242.       
  243. !     man_globals->current_directory = INITIAL_DIR;
  244.       MakeDirectoryBox(man_globals, mpw->directory,
  245. !              mpw->box + man_globals->current_directory, 
  246. !              man_globals->current_directory );
  247.       XtManageChild(mpw->box[man_globals->current_directory]);
  248.     }
  249.   
  250.   /* Create Manpage */
  251.   
  252. !   font_height = (resources.fonts.normal->max_bounds.ascent + 
  253. !            resources.fonts.normal->max_bounds.descent);
  254.   
  255.     num_args = 0;
  256.     XtSetArg(arglist[num_args], XtNallowVert, TRUE);
  257. ***************
  258. *** 285,291 ****
  259.       if (man_globals->both_shown) {
  260.         XtManageChild(dir);
  261.         man_globals->dir_shown = TRUE;
  262. !       XtPanedSetMinMax(dir, directory_height, directory_height);
  263.         XtSetSensitive(man_globals->put_up_manpage,FALSE);
  264.         XtSetSensitive(man_globals->put_up_directory,FALSE);
  265.         ChangeLabel(man_globals->both_shown_button, SHOW_ONE);
  266. --- 296,303 ----
  267.       if (man_globals->both_shown) {
  268.         XtManageChild(dir);
  269.         man_globals->dir_shown = TRUE;
  270. !       XtPanedSetMinMax(dir, resources.directory_height, 
  271. !                resources.directory_height);
  272.         XtSetSensitive(man_globals->put_up_manpage,FALSE);
  273.         XtSetSensitive(man_globals->put_up_directory,FALSE);
  274.         ChangeLabel(man_globals->both_shown_button, SHOW_ONE);
  275. ***************
  276. *** 320,326 ****
  277.    */
  278.   
  279.     XtRealizeWidget(  man_globals->This_Manpage );
  280. !   AddCursor( man_globals->This_Manpage, cursors.manpage);
  281.     XtPanedSetMinMax(dir, 1, 10000); 
  282.   }
  283.   
  284. --- 332,340 ----
  285.    */
  286.   
  287.     XtRealizeWidget(  man_globals->This_Manpage );
  288. !   XtMapWidget( man_globals->This_Manpage );
  289. ! 
  290. !   AddCursor( man_globals->This_Manpage, resources.cursors.manpage);
  291.     XtPanedSetMinMax(dir, 1, 10000); 
  292.   }
  293.   
  294. ***************
  295. *** 467,473 ****
  296.     MakeLong((Widget) pupwidget);
  297.   
  298.     XtRealizeWidget(popup_shell);    /* Realize it and change its cursor. */
  299. !   AddCursor(popup_shell,cursors.top);
  300.   }
  301.   
  302.   /*    Function Name: MakeDirPopUpWidget
  303. --- 481,487 ----
  304.     MakeLong((Widget) pupwidget);
  305.   
  306.     XtRealizeWidget(popup_shell);    /* Realize it and change its cursor. */
  307. !   AddCursor(popup_shell,resources.cursors.top);
  308.   }
  309.   
  310.   /*    Function Name: MakeDirPopUpWidget
  311. ***************
  312. *** 494,513 ****
  313.     Arg args[1];            /* The argument list. */
  314.     int i;            /* A counter. */
  315.     Cardinal num_args = 0;    /* The number of arguments. */
  316. -   static char * name[MAXSECT];    /*the names of of the popups */
  317.   
  318. - /* Get the names from the manual structure. */
  319. - 
  320. -   for ( i = 1; i < sections; i++)
  321. -     name[i - 1] = manual[i].blabel;
  322. - 
  323.     popup_shell = XtCreatePopupShell( SPOPUPNAME, overrideShellWidgetClass,
  324.                      widget, NULL, (Cardinal) 0);
  325.     XtSetArg(args[num_args],XtNjustify,XtJustifyLeft); 
  326.     num_args++;
  327.   
  328. !   popup.number = sections - 1;    /* We ignore section (0) even though it is
  329. !                    in the manual structure. */
  330.     popup.name = "Manual Sections";
  331.     popup.label_args = NULL;
  332.     popup.label_num = (Cardinal) 0;
  333. --- 508,520 ----
  334.     Arg args[1];            /* The argument list. */
  335.     int i;            /* A counter. */
  336.     Cardinal num_args = 0;    /* The number of arguments. */
  337.   
  338.     popup_shell = XtCreatePopupShell( SPOPUPNAME, overrideShellWidgetClass,
  339.                      widget, NULL, (Cardinal) 0);
  340.     XtSetArg(args[num_args],XtNjustify,XtJustifyLeft); 
  341.     num_args++;
  342.   
  343. !   popup.number = sections;
  344.     popup.name = "Manual Sections";
  345.     popup.label_args = NULL;
  346.     popup.label_num = (Cardinal) 0;
  347. ***************
  348. *** 518,525 ****
  349.     popup.buttons = buttons;
  350.     popup.callback = DirPopUpCallback;
  351.   
  352. !   for ( i = 0 ; i < sections - 1; i ++) {
  353. !     buttons[i].name = name[i];
  354.       buttons[i].number_per_line = 0;
  355.     }
  356.   
  357. --- 525,532 ----
  358.     popup.buttons = buttons;
  359.     popup.callback = DirPopUpCallback;
  360.   
  361. !   for ( i = 0 ; i < sections; i ++) {
  362. !     buttons[i].name = manual[i].blabel;
  363.       buttons[i].number_per_line = 0;
  364.     }
  365.   
  366. ***************
  367. *** 529,566 ****
  368.     XtManageChild(pupwidget);
  369.     (void) MakeLong(pupwidget);
  370.     XtRealizeWidget(popup_shell);
  371. !   AddCursor(popup_shell,cursors.top);
  372.   }
  373.   
  374.   /*    Function Name: CreateManpageName
  375.    *    Description: Creates the manual page name for a given item.
  376. !  *    Arguments: filename - the filename to convert.
  377.    *    Returns: the manual page properly allocated.
  378.    */
  379.   
  380.   /*
  381. !  * If the filename is foo.c - Create an entry of the form:  foo
  382. !  * If the filename is foo.cX - Create an entry of the form: foo(X)
  383.    */
  384.   
  385.   char *
  386. ! CreateManpageName(filename)
  387. ! char * filename;
  388.   {
  389. !   char * cp, temp[BUFSIZ];
  390.   
  391. !   strcpy(temp, filename);
  392. !   cp = rindex(temp, '.');
  393. !   if (cp[2] != '\0') {
  394. !     *cp++ = '(';  
  395. !     *cp++ = *(cp + 1);
  396.       *cp++ = ')';
  397.       *cp = '\0';
  398.     }
  399.     else
  400.       *cp = '\0';  
  401. !   
  402. !   return(StrAlloc(temp));
  403.   }
  404.   
  405.   /*    Function Name: CreateList
  406. --- 536,578 ----
  407.     XtManageChild(pupwidget);
  408.     (void) MakeLong(pupwidget);
  409.     XtRealizeWidget(popup_shell);
  410. !   AddCursor(popup_shell,resources.cursors.top);
  411.   }
  412.   
  413.   /*    Function Name: CreateManpageName
  414.    *    Description: Creates the manual page name for a given item.
  415. !  *    Arguments: entry - the entry to convert.
  416.    *    Returns: the manual page properly allocated.
  417.    */
  418.   
  419.   /*
  420. !  * If the filename is foo.3     - Create an entry of the form:  foo
  421. !  * If the filename is foo.3X11 
  422. !  * or foo.cX11.stuff            - Create an entry of the form:  foo(X11)
  423.    */
  424.   
  425.   char *
  426. ! CreateManpageName(entry)
  427. ! char * entry;
  428.   {
  429. !   char * cp;
  430. !   char page[BUFSIZ];
  431.   
  432. !   ParseEntry(entry, NULL, NULL, page);
  433. ! 
  434. !   cp = index(page, '.');
  435. !   if ( (cp[2] != '\0') && (cp[2] != '.') ) {
  436. !     *cp++ = '(';
  437. !     while( (cp[1] != '\0') && (cp[1] != '.') ) {
  438. !       *cp = cp[1]; cp++;
  439. !     }
  440.       *cp++ = ')';
  441.       *cp = '\0';
  442.     }
  443.     else
  444.       *cp = '\0';  
  445. ! 
  446. !   return(StrAlloc(page));
  447.   }
  448.   
  449.   /*    Function Name: CreateList
  450. ***************
  451. *** 581,587 ****
  452.   
  453.     for (current = ret_list, count = 0 ; count < manual[section].nentries ;
  454.          count++, current++)
  455. !     *current = CreateManpageName(manual[section].entries[count].label);
  456.    
  457.     *current = NULL;        /* NULL terminate the list. */
  458.     return(ret_list);
  459. --- 593,599 ----
  460.   
  461.     for (current = ret_list, count = 0 ; count < manual[section].nentries ;
  462.          count++, current++)
  463. !     *current = CreateManpageName(manual[section].entries[count]);
  464.    
  465.     *current = NULL;        /* NULL terminate the list. */
  466.     return(ret_list);
  467. ***************
  468. *** 618,624 ****
  469.     num_args++;
  470.     XtSetArg(arglist[num_args], XtNborderWidth, 0);
  471.     num_args++;
  472. !   XtSetArg(arglist[num_args], XtNfont, fonts.directory);
  473.     num_args++;
  474.     
  475.     *dir_disp = XtCreateWidget(DIRECTORY_NAME, listWidgetClass, parent,
  476. --- 630,636 ----
  477.     num_args++;
  478.     XtSetArg(arglist[num_args], XtNborderWidth, 0);
  479.     num_args++;
  480. !   XtSetArg(arglist[num_args], XtNfont, resources.fonts.directory);
  481.     num_args++;
  482.     
  483.     *dir_disp = XtCreateWidget(DIRECTORY_NAME, listWidgetClass, parent,
  484. ***************
  485. *** 669,675 ****
  486.                           arglist,num_args);
  487.     XtManageChild(box);
  488.     XtRealizeWidget(shell);
  489. !   AddCursor(shell,cursors.top);
  490.   
  491.     num_args = 0;
  492.     shell = XtCreatePopupShell("likeToSave",transientShellWidgetClass,
  493. --- 681,687 ----
  494.                           arglist,num_args);
  495.     XtManageChild(box);
  496.     XtRealizeWidget(shell);
  497. !   AddCursor(shell,resources.cursors.top);
  498.   
  499.     num_args = 0;
  500.     shell = XtCreatePopupShell("likeToSave",transientShellWidgetClass,
  501. ***************
  502. *** 727,731 ****
  503.   
  504.     XtManageChild(box);
  505.     XtRealizeWidget(shell);
  506. !   AddCursor(shell,cursors.top);
  507.   }
  508. --- 739,743 ----
  509.   
  510.     XtManageChild(box);
  511.     XtRealizeWidget(shell);
  512. !   AddCursor(shell,resources.cursors.top);
  513.   }
  514. *** /tmp/,RCSt1a17205    Fri Jan  6 18:56:49 1989
  515. --- clients/xman/man.c    Fri Jan  6 18:42:17 1989
  516. ***************
  517. *** 1,7 ****
  518.   /*
  519.    * xman - X window system manual page display program.
  520.    *
  521. !  * $XConsortium: man.c,v 1.2 88/09/06 17:48:10 jim Exp $
  522.    *
  523.    * Copyright 1987, 1988 Massachusetts Institute of Technology
  524.    *
  525. --- 1,7 ----
  526.   /*
  527.    * xman - X window system manual page display program.
  528.    *
  529. !  * $XConsortium: man.c,v 1.3 89/01/06 18:42:14 kit Exp $
  530.    *
  531.    * Copyright 1987, 1988 Massachusetts Institute of Technology
  532.    *
  533. ***************
  534. *** 20,49 ****
  535.    */
  536.   
  537.   #if ( !defined(lint) && !defined(SABER))
  538. !   static char rcs_version[] = "$Athena: man.c,v 4.0 88/08/31 22:12:33 kit Exp $";
  539.   #endif
  540.   
  541.   #include "globals.h"
  542.   
  543. - static void SetSectionNames();
  544. - static int GetSectNumber();
  545. - static void CheckMandesc();
  546. - 
  547.   static char error_buf[BUFSIZ];        /* The buffer for error messages. */
  548.   
  549. ! /*    Function Name: CmpEntryLabel - used in qsort().
  550. !  *    Description: compares to elements by using their labels.
  551. !  *    Arguments: e1, e2 - two elements to compare by label.
  552. !  *    Returns: an integer >, < or = 0.
  553. !  */
  554.   
  555. ! static int 
  556. ! CmpEntryLabel(e1, e2) 
  557. ! struct entry *e1, *e2;
  558. ! {
  559. !   return(strcmp(e1->label, e2->label));
  560. ! }
  561.   
  562.   /*    Function Name: Man
  563.    *    Description: Builds a list of all manual directories and files.
  564.    *    Arguments: none. 
  565. --- 20,46 ----
  566.    */
  567.   
  568.   #if ( !defined(lint) && !defined(SABER))
  569. !   static char rcs_version[] = "$Athena: man.c,v 4.5 88/12/19 13:47:35 kit Exp $";
  570.   #endif
  571.   
  572.   #include "globals.h"
  573.   
  574.   static char error_buf[BUFSIZ];        /* The buffer for error messages. */
  575.   
  576. ! static void SortList(), ReadMandescFile(), SortAndRemove(), InitManual();
  577. ! static void AddToCurrentSection(), AddNewSection(), AddStandardSections();
  578. ! static int CmpEntryLabel();
  579.   
  580. ! #define SECT_ERROR -1
  581. ! #define streq(a, b)        ( strcmp((a), (b)) == 0 )
  582.   
  583. + typedef struct _SectionList {
  584. +   struct _SectionList * next;    /* link to next elem in list. */
  585. +   char * label, *directory;    /* The label and directory that this 
  586. +                    section represents. */
  587. +   Boolean standard;        /* Is this one of the standard sections? */
  588. + } SectionList;
  589. + 
  590.   /*    Function Name: Man
  591.    *    Description: Builds a list of all manual directories and files.
  592.    *    Arguments: none. 
  593. ***************
  594. *** 53,351 ****
  595.   int
  596.   Man()
  597.   {
  598. !   char *man_nomatch[MAXSECT + 1]; /* allow NULL termination. */
  599. !   char *manptr, manualdir[BUFSIZ], *local_ptr;
  600. !   int i,current[MAXSECT],nsect;
  601.   
  602. !   nsect = FIXEDSECT;
  603.   
  604. !   for (i = 0 ; i < MAXSECT ; i ++) {
  605. !     current[i] = 0;        /* set current entries = 0. */
  606. !     if ( (manual[i].entries = 
  607. !       (struct entry *) malloc(MAXENTRY * sizeof(struct entry))) == NULL )
  608. !       PrintError("Could not allocate memory, while building manpage list.");
  609. !     
  610. !     manual[i].blabel = "Dummy Section Label";
  611. !     manual[i].longest = 1;
  612. !   }
  613.   
  614. !   SetManNames(manual);
  615. !   manptr = getenv("MANPATH");
  616. !   if (manptr == NULL || strcmp(manptr,"") == 0) {
  617. ! #ifdef DEBUG  /* Since man does not complain we had better not either. */
  618. !     sprintf(error_buf,"Could not find MANPATH searching only, %s.",MANDIR);
  619. !     PrintWarning(error_buf);
  620. ! #endif
  621. !     strcpy(manualdir,MANDIR);
  622.     }
  623. !   else
  624. !     strcpy(manualdir,manptr);
  625.   
  626. !   local_ptr = manualdir;
  627. !   do {
  628. !     char *man[MAXSECT];
  629. !     char *curmandir;
  630. !     if ( (manptr = index(local_ptr,':')) != NULL) {    
  631. !       *manptr = '\0';
  632. !       curmandir = local_ptr;
  633. !       local_ptr = manptr + 1;
  634. !     }
  635. !     else
  636. !       curmandir = local_ptr;
  637.   
  638. ! /*    if (!Preformatted(curmandir, manual, current, nsect)) { */
  639. !       if (GetEntry(curmandir,man_nomatch)) {
  640. !     MatchEntries(curmandir,manual,man_nomatch,man,&nsect);
  641. !     AddStruct(manual,curmandir,man,current,nsect);
  642.         }
  643. ! /*    } */
  644.   
  645. !   } while (manptr != NULL);
  646. ! 
  647. !   SetSectionNames(manual);
  648. !   SortAndRemove(manual, nsect);
  649. ! #ifdef notdef
  650. !   DumpManual(nsect);
  651.   #endif
  652. !   return(nsect);        /* return the number of man sections. */
  653.   }    
  654.   
  655. ! /*    Function Name: GetEntry
  656. !  *    Description: This function gets the names of the manual page
  657. !  *                   directories, then closes the directory.
  658. !  *    Arguments: path - the path to this directory.
  659. !  *                 man - The directries of unformatted manual pages.
  660. !  *    Returns: FALSE if directory could not be opened.
  661.    */
  662.   
  663. ! static Boolean
  664. ! GetEntry(path, man)
  665. ! char * path;
  666. ! char * man[MAXSECT];
  667.   {
  668. !   DIR * dir;
  669. !   struct stat sb;
  670. !   register struct direct *dp;
  671. !   int numberman;
  672. !   char full_path[BUFSIZ];
  673.   
  674. !   numberman = 0;
  675.   
  676. !   /*
  677. !    * Read through this directory and save up any directory name
  678. !    * which begins with "man".
  679. !    */
  680. !   
  681. !   if((dir = opendir(path)) == NULL) {    
  682. !     sprintf(error_buf,"Can't open directory %s", path);
  683. !     PrintWarning(error_buf);
  684. !     return(FALSE);
  685. !   }
  686.   
  687. !   while((dp = readdir(dir)) != NULL) {
  688. !     if((dp->d_namlen >= LSEARCHDIR) && 
  689. !        (strncmp(dp->d_name, SEARCHDIR, LSEARCHDIR) == 0)) {
  690. !       if(numberman == MAXSECT) 
  691. !     PrintError(
  692. !       "Too many manual sections, recompile with larger allocations");
  693. !       sprintf(full_path, "%s/%s", path, dp->d_name);
  694. !       if((stat(full_path, &sb) >= 0) && (sb.st_mode & S_IFDIR))
  695. !     man[numberman++] = StrAlloc(dp->d_name);
  696.       }
  697.     }
  698. -   
  699. -   man[numberman] = NULL;    /* NULL terminate this list. */
  700. -   closedir(dir);
  701. -   return(TRUE);
  702. - }
  703.   
  704. ! /*    Function Name: MatchEntries
  705. !  *    Description: This fucntion gives the correct number to the 
  706. !  *                   directory, so that all manl entries will be 
  707. !  *                   in the same place.
  708. !  *    Arguments: path - path name if the current searched directory.
  709. !  *                 manual - a pointer to the manual structure.
  710. !  *                 manin - the unmatched states of the directories.
  711. !  *                 manout - the new wonderfully matched directories.
  712. !  *                 number - a pointer to the current number of sections.
  713. !  *    Returns: manout.
  714.    */
  715.   
  716. ! void
  717. ! MatchEntries(path,manual,manin,manout,number)
  718. ! char * path;
  719. ! Manual * manual;
  720. ! char **manin;
  721. ! char **manout;
  722. ! int *number;
  723. ! {
  724. !   int sect;
  725. ! 
  726. !   bzero((char *) manout, MAXSECT * sizeof(char *));
  727. ! 
  728. !   for ( ; *manin != NULL ; manin++) {
  729. !     if ( (sect = GetSectNumber( (*manin)[LMAN] )) >= 0) 
  730. !       manout[sect] = *manin;
  731.     }
  732.   
  733. !   CheckMandesc(path, manout, manual, number);
  734. ! }
  735. ! 
  736. ! /*    Function Name: CheckMandesc
  737.    *    Description: Reads the mandesc file, and adds more sections as 
  738.    *                   nescessary.
  739. !  *    Arguments: path - path name if the current searched directory.
  740. !  *                 manual - a pointer to the manual structure.
  741. !  *                 man - directories, now sorted by order.
  742. !  *                 number - a pointer to the current number of sections.
  743. !  *    Returns: none
  744.    */
  745.     
  746.   static void
  747. ! CheckMandesc(path, manout, manual, number)
  748. ! int *number;
  749.   char * path;
  750. - char ** manout;
  751. - Manual * manual;
  752.   {
  753.     char mandesc_file[BUFSIZ];    /* full path to the mandesc file. */
  754.     FILE * descfile;
  755. !   char character;
  756. !   char string[BUFSIZ];
  757. !   int sectnum;
  758. !   register int j;
  759.   
  760.     sprintf(mandesc_file, "%s/%s", path, MANDESC);
  761. !   if ( (descfile = fopen(mandesc_file, "r")) == NULL) 
  762. !     return;            /* if no description file we are done. */
  763. !   while ( (character = getc(descfile)) != EOF) {
  764. !     Boolean flag = TRUE;
  765.   
  766. !     fgets(string, 100, descfile);
  767. !     string[strlen(string)-1] = '\0';        /* Strip off the CR. */
  768. !     if ( (sectnum = GetSectNumber(character)) >= 0) {
  769. !       if (manout[sectnum] == NULL) {
  770. !     sprintf(error_buf, "Error in file: %s.", mandesc_file);
  771. !     PrintWarning(error_buf);
  772. !     sprintf(error_buf, "Could not find the directory %s/man%c.", 
  773. !         path, character);
  774. !     PrintWarning(error_buf);
  775.       continue;
  776.         }
  777. !       for (j = FIXEDSECT ; j < *number ; j++) {
  778. ! /*
  779. !  * If this section exists then do not create a new one for it.
  780. !  */
  781. !     if ( (!strcmp(manual[j].blabel , string)) ) {
  782. !       manout[j] = manout[sectnum];
  783. !       flag = FALSE;
  784. !     }
  785. !       }
  786. !       if (flag) {
  787. !     manual[*number].blabel = StrAlloc(string);
  788. !     manual[*number].sect = StrAlloc(manout[sectnum]);
  789. !     manout[*number] = StrAlloc(manout[sectnum]);
  790. !     if ( ++(*number) >= MAXSECT) {
  791. !       sprintf(error_buf,"Number of sections exceeded %d recompile %s",
  792. !           MAXSECT,"with larger MAXSECT.");
  793. !         PrintError(error_buf);
  794. !     }
  795. !       } 
  796. !       manout[sectnum][0] = '\0'; /* remove it's name for the prev place */
  797.       }
  798. !     else { /* (sectnum = GetSectNumber(character)) >= 0) */
  799. !       sprintf(error_buf, "Unknown man directory 'man%s'.", character);
  800. !       PrintWarning(error_buf);
  801. !     }
  802.     }
  803. !   fclose(descfile);
  804.   }
  805.   
  806. ! /*    Function Name: AddStruct
  807. !  *    Description: add the new entries to the manual structure.
  808. !  *    Arguments: manual - the manual structure to add them to.
  809. !  *                 path   - the man path for these entires.
  810. !  *                 man  - a pointer to the man directory names. 
  811. !  *                 current - a pointer to the number of the current entry.
  812. !  *    Returns: current - new current pointer numbers and changes manual
  813.    */
  814.   
  815. ! void
  816. ! AddStruct(manual,path,man,current,number)
  817. ! Manual * manual;
  818.   char * path;
  819. - char * man[MAXSECT];
  820. - int current[MAXSECT];
  821. - int number;
  822.   {
  823. !   int i;
  824. !   DIR * dir;
  825. !   register struct direct *dp;
  826. !   char section[BUFSIZ];
  827.   
  828. !   /*
  829. !    * Go through each manual directory saving up the individual
  830. !    * page entries.
  831. !    * Demand that a page entry not start with a '.' but have
  832. !    * a dot somewhere.
  833. !    */
  834.   
  835. !   for(i=0; i < number; i++,man++) {
  836. !     register int j, k;
  837. !     int longest, lpixels;
  838.   
  839. !     longest = lpixels = 1;    /* prevents division by zero. */
  840. !     k = current[i];
  841.   
  842. !     path = StrAlloc(path);    /* allocate a space to save the path. */
  843.   
  844. !     /* 
  845. !      * Use the man directories to get the file names 'cause they should be 
  846. !      * more complete. 
  847. !      */ 
  848.   
  849. !     if (*man == NULL)
  850. !       continue;
  851. !     sprintf(section,"%s/%s",path, *man);
  852. !     if ( (dir = opendir(section)) == NULL) {
  853. !       sprintf(error_buf, "Could not open directory %s.", section);
  854. !       PrintWarning(error_buf);
  855. !       continue;
  856. !     }
  857.   
  858. !     while((dp = readdir(dir)) != NULL) {
  859. !       if( k >= MAXENTRY) {
  860. !     sprintf(error_buf,"Too many manual pages in %s %s", section,
  861. !         "Try recompiling with larger allocations");
  862. !     PrintError(error_buf);
  863. !       }
  864. !       /* starts with a dot? no dot in name? */
  865. !       if( (dp->d_name[0] == '.') || (rindex(dp->d_name,'.') == NULL) )
  866. !     continue;
  867. !       manual[i].entries[k].label = StrAlloc(dp->d_name);
  868. !       manual[i].entries[k].path = path;
  869. !       k++;
  870. ! /* 
  871. !  * This sets the value of the longest string in characters and pixels, I have
  872. !  * to play a few games since the longest string in characters is not 
  873. !  * nescessarily the longest string in pixels, and XTextWidth is not very fast.
  874.    */
  875. !       if ((j = strlen(dp->d_name)) >= longest - 2) {
  876. !     longest = j;
  877. !     if  ( (j = XTextWidth(fonts.directory,dp->d_name,strlen(dp->d_name))) >
  878. !          lpixels)
  879. !     lpixels = j;
  880. !       }
  881.       }
  882. !     closedir(dir);
  883. ! /*
  884. !  * Yes, this check is needed, because we may add to the structure more 
  885. !  * than once, depending on the MANPATH.
  886. !  */
  887. !     if ( (lpixels + 5) > manual[i].longest)
  888. !       manual[i].longest = lpixels+5;
  889. !     current[i] = manual[i].nentries = k;
  890.     }
  891.   }
  892.   
  893.   /*    Function Name: SortAndRemove
  894. --- 50,348 ----
  895.   int
  896.   Man()
  897.   {
  898. !   SectionList *list = NULL;
  899. !   char *ptr, manpath[BUFSIZ], *path, *current_label;
  900. !   int sect;
  901.   
  902. ! /* 
  903. !  * Get the environment variable MANPATH, and if it doesn't exist then back
  904. !  * up to MANDIR.
  905. !  */
  906.   
  907. !   ptr = getenv("MANPATH");
  908. !   if (ptr == NULL || streq(ptr , "") )
  909. !     ptr = MANDIR;
  910. !   strcpy(manpath, ptr);
  911.   
  912. ! /*
  913. !  * Get the list of manual directories in the users MANPATH that we should
  914. !  * open to look for manual pages.  The ``mandesc'' file is read here.
  915. !  */
  916. ! 
  917. !   for ( path = manpath ; (ptr = index(path , ':')) != NULL ; path = ++ptr) { 
  918. !     *ptr = '\0';
  919. !     ReadMandescFile(&list, path);
  920.     }
  921. !   ReadMandescFile(&list, path);
  922.   
  923. !   SortList(&list);
  924.   
  925. !   sect = 0;
  926. !   InitManual( &(manual[sect]), list->label );
  927. !   current_label = NULL;
  928. !   while ( list != NULL ) {
  929. !     SectionList * old_list;
  930. ! 
  931. !     if ( current_label == NULL || streq(list->label, current_label) )
  932. !       AddToCurrentSection( &(manual[sect]), list->directory);
  933. !     else {
  934. !       if (manual[sect].nentries == 0) {    /* empty section, re-use it. */
  935. !     free(manual[sect].blabel);
  936. !     manual[sect].blabel = list->label;
  937.         }
  938. !       else {
  939. !     if ( ++sect >= MAXSECT ) {
  940. !       sprintf(error_buf, "%s %s", "Too many manual sections, recompile",
  941. !           "with a larger value for MAXSECT.");
  942. !       PrintError(error_buf);
  943. !     }
  944. !     InitManual( &(manual[sect]), list->label );
  945. !       }
  946. !       AddToCurrentSection( &(manual[sect]), list->directory);
  947. !     }
  948. !     /* Save label to see if it matches next entry. */
  949. !     current_label = list->label; 
  950. !     old_list = list;
  951. !     list = list->next;
  952. !     free(old_list);        /* free what you allocate. */
  953. !   }
  954. !   if (manual[sect].nentries != 0)
  955. !     sect++;            /* don't forget that last section. */
  956. !   
  957. !   SortAndRemove(manual, sect);
  958.   
  959. ! #ifdef notdef            /* dump info. */
  960. !   DumpManual(sect);
  961.   #endif
  962. !   return(sect);        /* return the number of man sections. */
  963.   }    
  964.   
  965. ! /*    Function Name: SortList
  966. !  *    Description: Sorts the list of sections to search.
  967. !  *    Arguments: list - a pointer to the list to sort.
  968. !  *    Returns: a sorted list.
  969. !  *
  970. !  * This is the most complicated part of the entire operation.
  971. !  * all sections with the same label must by right next to each other,
  972. !  * but the sections that are in the standard list have to come first.
  973.    */
  974.   
  975. ! static void
  976. ! SortList(list)
  977. ! SectionList ** list;
  978.   {
  979. !   SectionList * local;
  980. !   SectionList *head, *last, *inner, *old;
  981. !   
  982. !   if (*list == NULL)
  983. !     PrintError("No manual sections to read, exiting.");
  984.   
  985. ! /* 
  986. !  * First step 
  987. !  * 
  988. !  * Look for standard list items, and more them to the top of the list.
  989. !  */
  990.   
  991. !   last = NULL;            /* keep Saber happy. */
  992. !   for ( local = *list ; local->next != NULL ; local = local->next) {
  993. !     if ( local->standard ) {
  994. !       if ( local == *list )    /* top element is already standard. */
  995. !     break;
  996. !       head = local;
  997.   
  998. !       /* Find end of standard block */
  999. !       for ( ; (local->next != NULL) && (local->standard) 
  1000. !        ; old = local, local = local->next); 
  1001. ! 
  1002. !       last->next = old->next; /* Move the block. */
  1003. !       old->next = *list;
  1004. !       *list = head;
  1005. ! 
  1006. !       break;            /* First step accomplished. */
  1007.       }
  1008. +     last = local;
  1009.     }
  1010.   
  1011. ! /*
  1012. !  *  Second step
  1013. !  *
  1014. !  *  Move items with duplicate labels right next to each other.
  1015.    */
  1016.   
  1017. !   local = *list;
  1018. !   for ( local = *list ; local->next != NULL ; local = local->next) {
  1019. !     inner = local->next;
  1020. !     while ( inner != NULL) {
  1021. !       if ( streq(inner->label, local->label) && (inner != local->next)) {
  1022. !     last->next = inner->next; /* Move it to directly follow local. */
  1023. !     inner->next = local->next;
  1024. !     local->next = inner;
  1025. !     inner = last;        /* just so that we keep marching down the
  1026. !                    tree (this keeps us from looping). */
  1027. !       }
  1028. !       last = inner;
  1029. !       inner = inner->next;
  1030. !     }
  1031.     }
  1032. + }    
  1033.   
  1034. ! /*    Function Name: ReadMandescFile
  1035.    *    Description: Reads the mandesc file, and adds more sections as 
  1036.    *                   nescessary.
  1037. !  *    Arguments: path - path name if the current search directory.
  1038. !  *                 section_list - pointer to the list of sections.
  1039. !  *    Returns: TRUE in we should use default sections
  1040.    */
  1041.     
  1042.   static void
  1043. ! ReadMandescFile( section_list, path )
  1044. ! SectionList ** section_list;
  1045.   char * path;
  1046.   {
  1047.     char mandesc_file[BUFSIZ];    /* full path to the mandesc file. */
  1048.     FILE * descfile;
  1049. !   char string[BUFSIZ], local_file[BUFSIZ];
  1050. !   Boolean use_defaults = TRUE;
  1051.   
  1052.     sprintf(mandesc_file, "%s/%s", path, MANDESC);
  1053. !   if ( (descfile = fopen(mandesc_file, "r")) != NULL) {
  1054. !     while ( fgets(string, BUFSIZ, descfile) != NULL) {
  1055. !       string[strlen(string)-1] = '\0';        /* Strip off the CR. */
  1056.   
  1057. !       if ( streq(string, NO_SECTION_DEFAULTS) ) {
  1058. !     use_defaults = FALSE;
  1059.       continue;
  1060.         }
  1061. ! 
  1062. !       sprintf(local_file, "%s%c", MAN, string[0]);
  1063. !       AddNewSection(section_list, path, local_file, (string + 1), FALSE );
  1064.       }
  1065. !     fclose(descfile);
  1066.     }
  1067. !   if (use_defaults)
  1068. !     AddStandardSections(section_list, path);
  1069.   }
  1070.   
  1071. ! /*    Function Name: AddStandardSections
  1072. !  *    Description: Adds all the standard sections to the list for this path.
  1073. !  *    Arguments: list - a pointer to the section list.
  1074. !  *                 path - the path to these standard sections.
  1075. !  *    Returns: none.
  1076.    */
  1077.   
  1078. ! static void
  1079. ! AddStandardSections(list, path)
  1080. ! SectionList **list;
  1081.   char * path;
  1082.   {
  1083. !   static char * names[] = {
  1084. !     "User Commands       (1)",
  1085. !     "System Calls        (2)",
  1086. !     "Subroutines         (3)",
  1087. !     "Devices             (4)",
  1088. !     "File Formats        (5)",
  1089. !     "Games               (6)",
  1090. !     "Miscellaneous       (7)",
  1091. !     "Sys. Administration (8)",
  1092. !     "Local               (l)",
  1093. !     "New                 (n)",
  1094. !     "Old                 (o)",
  1095. !     };
  1096. !   register int i;
  1097. !   char file[BUFSIZ];
  1098.   
  1099. !   for (i = 1 ; i <= 8 ; i++) {
  1100. !     sprintf(file, "%s%d", MAN, i);
  1101. !     AddNewSection(list, path, file, names[i-1], TRUE);
  1102. !   }
  1103. !   i--;
  1104. !   sprintf(file, "%sl", MAN);
  1105. !   AddNewSection(list, path, file, names[i++], TRUE);
  1106. !   sprintf(file, "%sn", MAN);
  1107. !   AddNewSection(list, path, file, names[i++], TRUE);
  1108. !   sprintf(file, "%so", MAN);
  1109. !   AddNewSection(list, path, file, names[i], TRUE);
  1110. ! }
  1111.   
  1112. ! /*    Function Name: AddNewSection
  1113. !  *    Description: Adds the new section onto the current section list.
  1114. !  *    Arguments: list - pointer to the section list.
  1115. !  *                 path - the path to the current manual section.
  1116. !  *                 file - the file to save.
  1117. !  *                 label - the current section label.
  1118. !  *                 standard - one of the standard labels?
  1119. !  *    Returns: none.
  1120. !  */
  1121.   
  1122. ! static void
  1123. ! AddNewSection(list, path, file, label, standard)
  1124. ! SectionList **list;
  1125. ! char * path, * label, * file;
  1126. ! Boolean standard;
  1127. ! {
  1128. !   SectionList * local_list, * end;
  1129. !   char full_path[BUFSIZ];
  1130.   
  1131. ! /* Allocate a new list element */
  1132.   
  1133. !   if ( (local_list = (SectionList *) malloc(sizeof(SectionList)) ) == NULL)
  1134. !     PrintError("Could not allocate Memory in AddNewSection.");
  1135.   
  1136. !   if (*list != NULL) {
  1137. !     for ( end = *list ; end->next != NULL ; end = end->next );
  1138. !     end->next = local_list;
  1139. !   }
  1140. !   else 
  1141. !     *list = local_list;
  1142.   
  1143. !   local_list->next = NULL;
  1144. !   local_list->label = StrAlloc(label);
  1145. !   sprintf(full_path, "%s/%s", path, file);
  1146. !   local_list->directory = StrAlloc(full_path);
  1147. !   local_list->standard = standard;
  1148. ! }  
  1149. ! 
  1150. ! /*    Function Name: AddToCurrentSection
  1151. !  *    Description: This function gets the names of the manual page
  1152. !  *                   directories, then closes the directory.
  1153. !  *    Arguments:  local_manual - a pointer to a manual pages structure.
  1154. !  *                  path - the path to this directory.
  1155. !  *    Returns: FALSE if directory could not be opened.
  1156.    */
  1157. ! 
  1158. ! static void
  1159. ! AddToCurrentSection(local_manual, path)
  1160. ! Manual * local_manual;
  1161. ! char * path;
  1162. ! {
  1163. !   DIR * dir;
  1164. !   register struct direct *dp;
  1165. !   register int nentries;
  1166. !   char full_name[BUFSIZ];
  1167. ! 
  1168. !   if((dir = opendir(path)) == NULL) {    
  1169. ! #ifdef DEBUG
  1170. !     sprintf(error_buf,"Can't open directory %s", path);
  1171. !     PrintWarning(NULL, error_buf);
  1172. ! #endif DEBUG
  1173. !     return;
  1174. !   }
  1175. !   
  1176. !   nentries = local_manual->nentries;
  1177. ! 
  1178. !   while( (dp = readdir(dir)) != NULL ) {
  1179. !     char * name = dp->d_name;
  1180. !     if( (name[0] == '.') || (index(name, '.') == NULL) ) 
  1181. !       continue;
  1182. !     if ( nentries >= MAXENTRY ) {
  1183. !       sprintf(error_buf, "%s %s %s", "Too many manual pages in directory",
  1184. !           path, "recompile with A larger value for MAXENTRY.");
  1185. !       PrintError(error_buf);
  1186.       }
  1187. !     sprintf(full_name, "%s/%s", path, name);
  1188. !     local_manual->entries[nentries++] = StrAlloc(full_name);
  1189.     }
  1190. +   local_manual->nentries = nentries;
  1191.   }
  1192.   
  1193.   /*    Function Name: SortAndRemove
  1194. ***************
  1195. *** 356,386 ****
  1196.    *    Returns: an improved manual stucure
  1197.    */
  1198.   
  1199. ! void
  1200.   SortAndRemove(manual, number)
  1201.   Manual *manual;
  1202.   int number;
  1203.   {
  1204.     int i;
  1205.   
  1206.     for ( i = 0; i < number; i++) { /* sort each section */
  1207.       register int j = 0;
  1208.       Manual * man = &(manual[i]);
  1209.   
  1210. !     qsort(man->entries, man->nentries, sizeof(struct entry), CmpEntryLabel);
  1211.   
  1212.       while (j < (man->nentries - 1) ) {
  1213. !       if (!strcmp(man->entries[j].label, man->entries[j+1].label)) {
  1214. !     register int k = 0;
  1215. !     for( k = j; k < (man->nentries -1); k++)
  1216. !       man->entries[j] = man->entries[j+1];
  1217.       (man->nentries)--;
  1218.         }
  1219. !       j++;
  1220.       }
  1221.     }
  1222.   }
  1223.   
  1224.   /*    Function Name: StrAlloc
  1225.    *    Description: this function allocates memory for a character string
  1226.    *      pointed to by sp and returns its new pointer.
  1227. --- 353,424 ----
  1228.    *    Returns: an improved manual stucure
  1229.    */
  1230.   
  1231. ! static void
  1232.   SortAndRemove(manual, number)
  1233.   Manual *manual;
  1234.   int number;
  1235.   {
  1236.     int i;
  1237. +   char *l1, *l2;
  1238.   
  1239.     for ( i = 0; i < number; i++) { /* sort each section */
  1240.       register int j = 0;
  1241.       Manual * man = &(manual[i]);
  1242.   
  1243. ! #ifdef DEBUG
  1244. !   printf("sorting section %d - %s\n", i, man->blabel);
  1245. ! #endif DEBUG
  1246.   
  1247. +     qsort(man->entries, man->nentries, sizeof( char * ), CmpEntryLabel);
  1248. + 
  1249. + #ifdef DEBUG
  1250. +     printf("removing from section %d.\n", i);
  1251. + #endif DEBUG
  1252. + 
  1253. +     if ( (l1 = rindex(man->entries[j], '/')) == NULL)
  1254. +       PrintError("Internal error while removing duplicate manual pages.");
  1255. +     j++;
  1256. + 
  1257.       while (j < (man->nentries - 1) ) {
  1258. !       l2 = l1;
  1259. !       if ( (l1 = rindex(man->entries[j], '/')) == NULL)
  1260. !     PrintError("Internal error while removing duplicate manual pages.");
  1261. !       if ( streq(l1, l2) ) {
  1262. !     register int k;
  1263. !     for( k = j; k < (man->nentries); k++)
  1264. !       man->entries[k - 1] = man->entries[k];
  1265.       (man->nentries)--;
  1266.         }
  1267. !       else
  1268. !     j++;
  1269.       }
  1270.     }
  1271.   }
  1272.   
  1273. + /*    Function Name: CmpEntryLabel - used in qsort().
  1274. +  *    Description: compares to elements by using their labels.
  1275. +  *    Arguments: e1, e2 - two items to compare.
  1276. +  *    Returns: an integer >, < or = 0.
  1277. +  */
  1278. + 
  1279. + static int 
  1280. + CmpEntryLabel(e1, e2) 
  1281. + char **e1, **e2;
  1282. + {
  1283. +   char *l1, *l2;
  1284. + 
  1285. + /*
  1286. +  * What we really want to compare is the actual names of the manual pages,
  1287. +  * and not the full path names.
  1288. +  */
  1289. + 
  1290. +   if ( (l1 = rindex(*e1, '/')) == NULL)
  1291. +     PrintError("Internal error while sorting manual pages.");
  1292. +   if ( (l2 = rindex(*e2, '/')) == NULL)
  1293. +     PrintError("Internal error while sorting manual pages.");
  1294. +   return( strcmp(l1, l2) );
  1295. + }
  1296. + 
  1297.   /*    Function Name: StrAlloc
  1298.    *    Description: this function allocates memory for a character string
  1299.    *      pointed to by sp and returns its new pointer.
  1300. ***************
  1301. *** 401,493 ****
  1302.     return(ret);
  1303.   }
  1304.   
  1305. ! /*    Function Name:  SetManNames
  1306. !  *    Description: This function give a name to manual.sect
  1307. !  *    Arguments: manual - pointer to the manual structure.
  1308. !  *    Returns: NONE.
  1309. !  */
  1310. ! 
  1311. ! void
  1312. ! SetManNames(manual)
  1313. ! Manual *manual;
  1314. ! {
  1315. !   int i;
  1316. !   char string[40];
  1317. ! 
  1318. !   for (i = 0; i < 9; i++) {
  1319. !     sprintf(string,"%s%d",MAN,i);
  1320. !     manual[i].sect = StrAlloc(string);
  1321. !   }
  1322. !   sprintf(string,"%s%c",MAN,'l');
  1323. !   manual[9].sect = StrAlloc(string);
  1324. !   sprintf(string,"%s%c",MAN,'n');
  1325. !   manual[10].sect = StrAlloc(string);
  1326. ! }
  1327. ! 
  1328. ! /*    Function Name: GetSectNumber
  1329. !  *    Description: this gets a section number of a fixed section.
  1330. !  *    Arguments: character - the character representing the section.
  1331. !  *    Returns: the number of that section.
  1332. !  */
  1333. ! 
  1334. ! static int
  1335. ! GetSectNumber(c)
  1336. ! char c;
  1337. ! {
  1338. ! 
  1339. !   switch (c) {
  1340. !   case '0':
  1341. !   case '1':
  1342. !   case '2':
  1343. !   case '3':
  1344. !   case '4':
  1345. !   case '5':
  1346. !   case '6':
  1347. !   case '7':
  1348. !   case '8':
  1349. !     return(c - '0');
  1350. !   case 'l':
  1351. !     return(9);
  1352. !   case 'n':
  1353. !     return(10);
  1354. !   default:
  1355. !     break;            /* ignore others, and return -1. */
  1356. !   }
  1357. !   return(-1);
  1358. ! }
  1359. ! 
  1360. ! /*    Function Name: SetSectNames
  1361. !  *    Description: Sets the section names.
  1362. !  *    Arguments: manual - the manual structure.
  1363.    *    Returns: none.
  1364.    */
  1365.   
  1366.   static void
  1367. ! SetSectionNames(manual)
  1368. ! Manual * manual;
  1369.   {
  1370. ! 
  1371. !   /* These are the names for the first 10 sections. */
  1372. ! 
  1373. !   static char * names[] = {
  1374. !     "foo bar (0)",
  1375. !     "User Commands (1)",
  1376. !     "System Calls (2)",
  1377. !     "Subroutines(3)",
  1378. !     "Devices (4)",
  1379. !     "File Formats (5)",
  1380. !     "Games (6)",
  1381. !     "Miscellaneous (7)",
  1382. !     "Sys. Administration (8)",
  1383. !     "Local (l)",
  1384. !     "New (n)"
  1385. !     };
  1386. !   register int i;
  1387. ! 
  1388. !   for (i = 1; i < FIXEDSECT; i++)
  1389. !     manual[i].blabel = names[i];
  1390.   }
  1391. ! 
  1392.   #if defined(DEBUG)
  1393.   
  1394.   /*    Function Name: DumpManual
  1395. --- 439,463 ----
  1396.     return(ret);
  1397.   }
  1398.   
  1399. ! /*    Function Name: InitManual
  1400. !  *    Description: Initializes this manual section.
  1401. !  *    Arguments: l_manual - local copy of the manual structure.
  1402. !  *                 label - the button label for this section.
  1403.    *    Returns: none.
  1404.    */
  1405.   
  1406.   static void
  1407. ! InitManual(l_manual, label)
  1408. ! Manual * l_manual;
  1409. ! char * label;
  1410.   {
  1411. !   bzero( l_manual, sizeof(Manual) );            /* clear it. */
  1412. !   l_manual->blabel = label;                    /* set label. */
  1413. !   l_manual->entries = (char **) malloc( sizeof(char *) * MAXENTRY);
  1414. !   if (l_manual->entries == NULL)
  1415. !     PrintError("Could not allocate memory in InitManual().");
  1416.   }
  1417. !   
  1418.   #if defined(DEBUG)
  1419.   
  1420.   /*    Function Name: DumpManual
  1421. ***************
  1422. *** 502,510 ****
  1423.     register int i,j;
  1424.     
  1425.     for ( i = 0; i < number; i++) {
  1426.       for (j = 0; j < manual[i].nentries; j++) 
  1427. !       printf("path %-10s label %-20s\n", manual[i].entries[j].path,
  1428. !          manual[i].entries[j].label);
  1429.     }
  1430.   }
  1431.   
  1432. --- 472,480 ----
  1433.     register int i,j;
  1434.     
  1435.     for ( i = 0; i < number; i++) {
  1436. +     printf("label: %s\n", manual[i].blabel);
  1437.       for (j = 0; j < manual[i].nentries; j++) 
  1438. !       printf("%s\n", manual[i].entries[j]);
  1439.     }
  1440.   }
  1441.   
  1442. *** /tmp/,RCSt1a17235    Fri Jan  6 18:56:59 1989
  1443. --- clients/xman/misc.c    Fri Jan  6 18:42:26 1989
  1444. ***************
  1445. *** 1,7 ****
  1446.   /*
  1447.    * xman - X window system manual page display program.
  1448.    *
  1449. !  * $XConsortium: misc.c,v 1.3 88/10/07 17:19:53 jim Exp $
  1450.    *
  1451.    * Copyright 1987, 1988 Massachusetts Institute of Technology
  1452.    *
  1453. --- 1,7 ----
  1454.   /*
  1455.    * xman - X window system manual page display program.
  1456.    *
  1457. !  * $XConsortium: misc.c,v 1.4 89/01/06 18:42:24 kit Exp $
  1458.    *
  1459.    * Copyright 1987, 1988 Massachusetts Institute of Technology
  1460.    *
  1461. ***************
  1462. *** 20,26 ****
  1463.    */
  1464.   
  1465.   #if ( !defined(lint) && !defined(SABER))
  1466. !   static char rcs_version[] = "$Athena: misc.c,v 4.0 88/08/31 22:13:01 kit Exp $";
  1467.   #endif
  1468.   
  1469.   #include "globals.h"
  1470. --- 20,26 ----
  1471.    */
  1472.   
  1473.   #if ( !defined(lint) && !defined(SABER))
  1474. !   static char rcs_version[] = "$Athena: misc.c,v 4.6 88/12/19 13:48:01 kit Exp $";
  1475.   #endif
  1476.   
  1477.   #include "globals.h"
  1478. ***************
  1479. *** 37,46 ****
  1480.    */
  1481.   
  1482.   void
  1483. ! PrintWarning(string)
  1484.   char * string;
  1485.   {
  1486. !   fprintf(stderr,"Xman Warning: %s\n",string);
  1487.   }
  1488.   
  1489.   /*    Function Name: PrintError
  1490. --- 37,54 ----
  1491.    */
  1492.   
  1493.   void
  1494. ! PrintWarning(man_globals, string)
  1495. ! ManpageGlobals * man_globals;
  1496.   char * string;
  1497.   {
  1498. !   char buffer[BUFSIZ];
  1499. ! 
  1500. !   sprintf( buffer, "Xman Warning: %s", string);
  1501. ! 
  1502. !   if (man_globals != NULL) 
  1503. !     ChangeLabel(man_globals->label, buffer);
  1504. ! 
  1505. !   fprintf(stderr, "%s\n", buffer);
  1506.   }
  1507.   
  1508.   /*    Function Name: PrintError
  1509. ***************
  1510. *** 63,88 ****
  1511.   /*    Function Name: FindFilename
  1512.    *    Description: Opens the entry file given the entry struct.
  1513.    *    Arguments: man_globals - the globals info for this manpage.
  1514. -  *                 name - name of the current manpage.
  1515.    *                 entry - the structure containg the info on the file to open.
  1516.    *    Returns: fp - the file pointer
  1517.    */
  1518.   
  1519.   FILE *
  1520. ! FindFilename(man_globals, name, section, entry)
  1521.   ManpageGlobals * man_globals;
  1522. ! char * name;
  1523. ! int section;
  1524. ! struct entry * entry;
  1525.   {
  1526.     FILE * file;
  1527. !   char local_filename[BUFSIZ];    /* local filename. */
  1528.   
  1529. !   sprintf(man_globals->manpage_title,
  1530. !       "The current manual page is: %s.", name);   
  1531.     
  1532. !   sprintf(man_globals->filename, "%s/%s%c/%s",
  1533. !       entry->path, CAT,  manual[section].sect[LCAT], entry->label);
  1534.   
  1535.   /* if we find the formatted manpage then return it */
  1536.   
  1537. --- 71,94 ----
  1538.   /*    Function Name: FindFilename
  1539.    *    Description: Opens the entry file given the entry struct.
  1540.    *    Arguments: man_globals - the globals info for this manpage.
  1541.    *                 entry - the structure containg the info on the file to open.
  1542.    *    Returns: fp - the file pointer
  1543.    */
  1544.   
  1545.   FILE *
  1546. ! FindFilename(man_globals, entry)
  1547.   ManpageGlobals * man_globals;
  1548. ! char * entry;
  1549.   {
  1550.     FILE * file;
  1551. !   char path[BUFSIZ], page[BUFSIZ], section[BUFSIZ], *temp;
  1552.   
  1553. !   temp = CreateManpageName(entry);
  1554. !   sprintf(man_globals->manpage_title, "The current manual page is: %s.", temp);
  1555. !   free(temp);
  1556.     
  1557. !   ParseEntry(entry, path, section, page);
  1558. !   sprintf(man_globals->filename, "%s/%s%c/%s", path, CAT, section[LCAT], page);
  1559.   
  1560.   /* if we find the formatted manpage then return it */
  1561.   
  1562. ***************
  1563. *** 89,109 ****
  1564.     if ( (file = fopen(man_globals->filename,"r")) != NULL)
  1565.       return(file);
  1566.   
  1567. ! /* If not then look for the unformatted man page, format it and 
  1568. !  * write access is allowed to the cat directory, then ask if we
  1569. !  * want to save it.
  1570. !  */
  1571. ! 
  1572. !   sprintf(local_filename,"%s/%s/%s",
  1573. !       entry->path, manual[section].sect, entry->label);
  1574. !   if ( (file = fopen(local_filename,"r")) == NULL) {
  1575. !     char error_buf[BUFSIZ];
  1576. !     /* We Really could not find it, this should never happen, yea right. */
  1577. !     sprintf(error_buf, "Could open manual page file, %s", local_filename);
  1578. !     PrintError(error_buf);
  1579. !   }
  1580. !   else 
  1581. !     return(Format(man_globals,file,local_filename, entry, section));
  1582.   }
  1583.   
  1584.   /*    Function Name: Format
  1585. --- 95,101 ----
  1586.     if ( (file = fopen(man_globals->filename,"r")) != NULL)
  1587.       return(file);
  1588.   
  1589. !   return(Format(man_globals, entry));
  1590.   }
  1591.   
  1592.   /*    Function Name: Format
  1593. ***************
  1594. *** 111,118 ****
  1595.    *                   with the user.
  1596.    *    Arguments: man_globals - the psuedo globals
  1597.    *                 file - the file pointer to use and return
  1598. -  *                 local_filename - the name of the file that is 
  1599. -  *                                  being formatted.
  1600.    *                 entry - the current entry struct.
  1601.    *                 current_box - The current directory being displayed. 
  1602.    *    Returns: none.
  1603. --- 103,108 ----
  1604. ***************
  1605. *** 121,138 ****
  1606.   /* ARGSUSED */
  1607.   
  1608.   FILE *
  1609. ! Format(man_globals, file, local_filename, entry, current_box)
  1610.   ManpageGlobals * man_globals; 
  1611. ! FILE * file;
  1612. ! char * local_filename;
  1613. ! struct entry * entry;
  1614. ! int current_box;        /* The current directory being displayed.  */
  1615.   {
  1616.     Widget w = man_globals->manpagewidgets.directory;
  1617. !   char cmdbuf[256];
  1618. !   char tmp[25];
  1619. !   char catdir[100];
  1620. !   int x,y;            /* location to pop up whould you 
  1621.                      like to save widget. */
  1622.   
  1623.     strcpy(tmp,MANTEMP);        /* get a temp file. */
  1624. --- 111,126 ----
  1625.   /* ARGSUSED */
  1626.   
  1627.   FILE *
  1628. ! Format(man_globals, entry)
  1629.   ManpageGlobals * man_globals; 
  1630. ! char * entry;
  1631.   {
  1632. +   FILE * file;
  1633.     Widget w = man_globals->manpagewidgets.directory;
  1634. !   char cmdbuf[BUFSIZ], tmp[BUFSIZ], catdir[BUFSIZ];
  1635. !   char path[BUFSIZ], section[BUFSIZ], error_buf[BUFSIZ];
  1636. ! 
  1637. !   Position x,y;            /* location to pop up whould you 
  1638.                      like to save widget. */
  1639.   
  1640.     strcpy(tmp,MANTEMP);        /* get a temp file. */
  1641. ***************
  1642. *** 157,187 ****
  1643.     XFlush(XtDisplay(w));
  1644.   */
  1645.   /* End replacement. */
  1646. ! /*
  1647. !   ChangeLabel(man_globals->label, "Formatting Manpage, Please Stand by...");
  1648. ! */
  1649.   #ifdef macII
  1650. !   sprintf(cmdbuf,"cd %s;/usr/bin/pcat %s | /usr/bin/col | /usr/bin/ul -t dumb > %s",
  1651. !       entry->path, local_filename, man_globals->tmpfile);
  1652.   #else
  1653. !   sprintf(cmdbuf,"cd %s;%s %s > %s",
  1654. !       entry->path,
  1655. !       FORMAT, local_filename, man_globals->tmpfile);
  1656.   #endif
  1657.   
  1658. !   if(system(cmdbuf) != 0)     /* execute search. */
  1659. !     PrintError("Something went wrong trying to run the command");
  1660.   
  1661.     if ((file = fopen(man_globals->tmpfile,"r")) == NULL) {  
  1662. !     PrintWarning("Something went wrong in retrieving the temp file");
  1663. !     PrintError("Try cleaning up /tmp");
  1664.     }
  1665.   
  1666.   /* if the catdir is writeable the ask the user if he/she wants to
  1667.      write the man page to it. */
  1668.   
  1669. !   sprintf(catdir,"%s/%s%c",
  1670. !       entry->path,CAT, manual[current_box].sect[LCAT], entry->label);
  1671.     
  1672.     if( (access(catdir,W_OK)) == 0)  {
  1673.       x = Width(man_globals->manpagewidgets.manpage)/2;
  1674. --- 145,187 ----
  1675.     XFlush(XtDisplay(w));
  1676.   */
  1677.   /* End replacement. */
  1678. ! 
  1679. !   if ( (file = fopen( entry , "r")) == NULL) {
  1680. !     /* We Really could not find it, this should never happen, yea right. */
  1681. !     sprintf(error_buf, "Could open manual page file, %s", entry);
  1682. !     PrintWarning(man_globals, error_buf);
  1683. !     return(NULL);
  1684. !   }
  1685. ! 
  1686. !   ParseEntry(entry, path, section, NULL);
  1687. ! 
  1688.   #ifdef macII
  1689. !   sprintf(cmdbuf,
  1690. !         "cd %s;/usr/bin/pcat %s | /usr/bin/col | /usr/bin/ul -t dumb > %s %s",
  1691. !     path, entry, man_globals->tmpfile, "2> /dev/null");
  1692.   #else
  1693. !   sprintf(cmdbuf,"cd %s ; %s %s > %s %s", path,
  1694. !       FORMAT, entry, man_globals->tmpfile, "2> /dev/null");
  1695.   #endif
  1696.   
  1697. !   if(system(cmdbuf) != 0) {    /* execute search. */
  1698. !     sprintf(error_buf,
  1699. !         "Something went wrong trying to run the command: %s", cmdbuf);
  1700. !     PrintWarning(man_globals, error_buf);
  1701. !     return(NULL);
  1702. !   }
  1703.   
  1704.     if ((file = fopen(man_globals->tmpfile,"r")) == NULL) {  
  1705. !     sprintf(error_buf, "Something went wrong in retrieving the temp file, %s",
  1706. !         "Try cleaning up /tmp");
  1707. !     PrintWarning(man_globals, error_buf);
  1708. !     return(NULL);
  1709.     }
  1710.   
  1711.   /* if the catdir is writeable the ask the user if he/she wants to
  1712.      write the man page to it. */
  1713.   
  1714. !   sprintf(catdir,"%s/%s%c", path, CAT, section[LCAT]);
  1715.     
  1716.     if( (access(catdir,W_OK)) == 0)  {
  1717.       x = Width(man_globals->manpagewidgets.manpage)/2;
  1718. ***************
  1719. *** 188,194 ****
  1720.       y = Height(man_globals->manpagewidgets.manpage)/2;
  1721.       XtTranslateCoords(man_globals->manpagewidgets.manpage, x, y, &x, &y);
  1722.       PositionCenter( PopupChild(man_globals->manpagewidgets.manpage, 0),
  1723. !            x,y,0,0,0,0);
  1724.       XtPopup( PopupChild(man_globals->manpagewidgets.manpage, 0),
  1725.           XtGrabExclusive);
  1726.     }
  1727. --- 188,194 ----
  1728.       y = Height(man_globals->manpagewidgets.manpage)/2;
  1729.       XtTranslateCoords(man_globals->manpagewidgets.manpage, x, y, &x, &y);
  1730.       PositionCenter( PopupChild(man_globals->manpagewidgets.manpage, 0),
  1731. !            (int) x, (int) y,0,0,0,0);
  1732.       XtPopup( PopupChild(man_globals->manpagewidgets.manpage, 0),
  1733.           XtGrabExclusive);
  1734.     }
  1735. ***************
  1736. *** 232,238 ****
  1737.   {
  1738.   
  1739.     if (!XtIsRealized(w)) {
  1740. !     PrintWarning("Widget is not realized, no cursor added.\n");
  1741.       return;
  1742.     }
  1743.     XDefineCursor(XtDisplay(w),XtWindow(w),cursor);
  1744. --- 232,238 ----
  1745.   {
  1746.   
  1747.     if (!XtIsRealized(w)) {
  1748. !     PrintWarning(NULL, "Widget is not realized, no cursor added.\n");
  1749.       return;
  1750.     }
  1751.     XDefineCursor(XtDisplay(w),XtWindow(w),cursor);
  1752. ***************
  1753. *** 316,318 ****
  1754. --- 316,352 ----
  1755.     XtMoveWidget(widget,x_temp,y_temp);
  1756.   }  
  1757.   
  1758. + /*    Function Name: ParseEntry(entry, path, sect, page)
  1759. +  *    Description: Parses the manual pages entry filenames.
  1760. +  *    Arguments: str - the full path name.
  1761. +  *                 path - the path name.      RETURNED
  1762. +  *                 sect - the section name.   RETURNED
  1763. +  *                 page - the page name.      RETURNED
  1764. +  *    Returns: none.
  1765. +  */
  1766. + 
  1767. + void
  1768. + ParseEntry(entry, path, sect, page)
  1769. + char *entry, *path, *page, *sect;
  1770. + {
  1771. +   char *c, temp[BUFSIZ];
  1772. + 
  1773. +   strcpy(temp, entry);
  1774. + 
  1775. +   c = rindex(temp, '/');
  1776. +   if (c == NULL) 
  1777. +     PrintError("index failure in ParseEntry.");
  1778. +   *c++ = '\0';
  1779. +   if (page != NULL)
  1780. +     strcpy(page, c);
  1781. + 
  1782. +   c = rindex(temp, '/');
  1783. +   if (c == NULL) 
  1784. +     PrintError("index failure in ParseEntry.");
  1785. +   *c++ = '\0';
  1786. +   if (sect != NULL)
  1787. +     strcpy(sect, c);
  1788. + 
  1789. +   if (path != NULL)
  1790. +     strcpy(path, temp);
  1791. + }
  1792. -- 
  1793. Mike Wexler(wyse!mikew)    Phone: (408)433-1000 x1330
  1794. Moderator of comp.sources.x
  1795.